home *** CD-ROM | disk | FTP | other *** search
/ Young Minds / Young Minds Interactive CD-ROM.ISO / crystal / cvact.c next >
Encoding:
C/C++ Source or Header  |  1988-01-12  |  20.4 KB  |  869 lines
  1. /* cvact.c
  2.  *    perform actions
  3.  *************************************************************************/
  4.  
  5. #include    <stdio.h>
  6. #include    "cvobj.h"
  7. #include    "cvocab.h"
  8. #include    "cvlocs.h"
  9. #include    "cvmisc.h"
  10. #include    "cvorcs.h"
  11. #include    "cvcode.h"
  12. #include    "random.h"
  13.  
  14. extern int actspk[]; /* cvocab.c */
  15. extern char *oword;
  16. extern void cvsave();
  17. extern void putcode();
  18. extern int mutilate();
  19. extern void juggle();
  20.  
  21. #define    OKAY(msg)    {rspeak(msg); return S_okay;}
  22. #define    DEFMSG    OKAY(actspk[verb%1000])
  23. #define    BREAKIT    {register int i; if (i = mutilate(object)) {\
  24.                     newloc = &(cvloc[i]); return S_move;\
  25.                 } else return S_okay; }
  26. #define    FILLIT(object,liquid)    {(object)->prop = (liquid) - _WATER + 1;}
  27. #define    INTRANS
  28. #define    TRANS    10000 + 
  29.  
  30. int
  31. suicide()
  32. {
  33.     pspeak(SELF,1);
  34.     die();
  35.     return S_show;
  36. }
  37.  
  38. static void
  39. dolight(object,state)
  40. register struct cvobj *object;
  41. register int state;
  42. {
  43.     if (object != LAMP) {
  44.         rspeak(180);
  45.     } else if (limit < 0) {
  46.         rspeak(184);
  47.     } else if (object->prop == state) {
  48.         rspeak(182-state); /* already in that state */
  49.     } else {
  50.         rspeak(40 - state);
  51.         object->prop = state;
  52.         if (DARK) {
  53.             rspeak(16);
  54.         }
  55.     }
  56.     return;
  57. }
  58.  
  59. int
  60. drownch()
  61. {
  62.     if (loc->flags & DROWN)
  63.     {    rspeak(120); /* You can't swim */
  64.         oldlc2 = loc; /* and all your stuff gets lost in the water */
  65.         die(); /* you guessed it! */
  66.         return TRUE;
  67.     } else {
  68.         return FALSE;
  69.     }
  70. }
  71.  
  72. void
  73. didorc()
  74. {    pspeak(ORCS,3); /* the orcs agree */
  75.     ORCS->prop = 0; /* now kill THEM off */
  76.     pspeak(IDOL,2); /* idol explodes (which is what kills the orcs) */
  77.     IDOL->prop = 0; /* make idol toteable */
  78.     destr2(IDOL); /* unfix the idol */
  79.     pspeak(IDOL,0); /* report the new state of the (now small) idol */
  80.     GIANT->prop = 1; /* Now for the BAD NEWS */
  81.     pspeak(GIANT,1); /* He's after you for sure */
  82.  
  83.     /* Now start giant (as the priest) and the balrog */
  84.     PRIEST->dloc = PRIEST->oloc = loc; /* he's right with you */
  85.     PRIEST->dseen = TRUE; /* of course */
  86.  
  87.     BALLY->dloc = BALLY->oloc = &(cvloc[141]); /* anchor ledge */
  88.     BALLY->dseen = FALSE; /* he'll get you later */
  89.     return;
  90. }
  91.  
  92. void
  93. newcon(object,p,liquid)
  94. register struct cvobj *object;
  95. register int p, liquid;
  96. {    pspeak(object,p); /* tell what the new contents are */
  97.     if (HERE(ORCS) && (ORCS->prop == 1) && (liquid == _COLA)) didorc();
  98. }
  99.  
  100. int
  101. drunkbear(object)
  102. register struct cvobj *object;
  103. {
  104.     BEAR->prop = 0;
  105.     object->prop = (object == KEG) ? 1 : 0;
  106.     move(object,loc);
  107.     juggle(BEAR);
  108.     move2(object,FIXED);
  109.     YOGI->dseen = FALSE;
  110.     YOGI->dloc = DEAD;
  111.     if (AXE->prop == 1 && AXE->conn2.where == FIXED) {
  112.         AXE->prop = 0;
  113.         destr2(AXE);
  114.     }
  115.     return S_show;
  116. }
  117.  
  118. int
  119. wakeking()
  120. {    HELM->prop = 0;
  121.     destry(HELM);
  122.     ARTHUR->dseen = TRUE;
  123.     ARTHUR->dloc = loc;
  124.     pspeak(HELM, 2); /* oops, he's after you */
  125.     return S_okay;
  126. }
  127.  
  128. int
  129. unicorn()
  130. {    pspeak(UNICRN,UNICRN->prop + 2);
  131.     if (UNICRN->prop == 1) {
  132.         destr2(UNICRN);
  133.         UNICRN->prop = 0;
  134.         EINHORN->dseen = FALSE;
  135.         EINHORN->dloc = EINHORN->oloc = DEAD;
  136.         pspeak(UNICRN,0);
  137.     }
  138.     return S_okay;
  139. }
  140.  
  141. int
  142. cvact(verb,obj,object) register int verb, obj;
  143. register struct cvobj *object;
  144. {
  145.     register int k;
  146.  
  147.     switch ((!!obj*10000) + verb)
  148.     {
  149.     case TRANS DROP:
  150.     case TRANS THROW:    /* a few cases handled elsewhere */
  151.     case INTRANS FEED:
  152.     case TRANS FEED:
  153.     case INTRANS POUR:
  154.     case TRANS POUR:
  155.     case INTRANS FILL:
  156.     case TRANS FILL:
  157.         return cvatt(verb,obj,object);
  158.  
  159.     case INTRANS SAVE:
  160.         cvsave();
  161.         OKAY(54);
  162.  
  163.     case INTRANS RESTOR:
  164.         cvrest();
  165.         rspeak(54);
  166.         return S_show;
  167.         
  168.     case INTRANS TAKE:
  169.         /* take what?  I can figure it out if there's only one thing here,
  170.         but otherwise, I complain. */
  171.         if ((loc->atloc.link == NULL) || (loc->atloc.link->link != NULL))
  172.         {    return S_what; }
  173.  
  174.         /* if there's liquid here, too, I get confused, which may just
  175.         confuse the adventurer, or may give him the hint he needs */
  176.         if (LIQLOC(loc)) { return S_what; }
  177.  
  178.         /* if the one object is the skeleton in attack mode, there's a
  179.         cutlass too, so we treat it as confusing, too */
  180.         if (HERE(SKELTN) && (SKELTN->prop == 1)) { return S_what; }
  181.  
  182.         /* if any creatures are here, they confuse things, too */
  183.         {    register struct monster *cre;
  184.  
  185.             for (cre = orcs; cre->iloc != -1; ++cre)
  186.             {    if (cre->dloc == loc) { return S_what; } }
  187.         }
  188.  
  189.         object = loc->atloc.link->who ;
  190.         obj = (object - cvobj) + 1000 ;
  191.  
  192.     case TRANS TAKE:
  193.         /* taking something
  194.          *    artifacts get destroyed (this should annoy the usual greedy
  195.                 players
  196.          *    liquids are treated specially, since they are shown as
  197.                 properties of places and vessels.
  198.          *    there are some other interesting side-effects, too!
  199.          */
  200.  
  201.         if ((object >= MINART) && (object <= MAXART)) BREAKIT ;
  202.         
  203.         if (HERE(DRAGON) && DRAGON->prop ) OKAY(203);
  204.  
  205.         if (object == SHOWER)
  206.         {    pspeak(SHOWER,1);
  207.             CRAP->prop = 0 ;
  208.             return S_okay;
  209.         }
  210.  
  211.         if ((object == ROPE)
  212.             && (TOTING(ROPE) || (ROPE->prop % 2) )
  213.             && HERE(ROPE2))
  214.         {    obj = _ROPE2; object = ROPE2; }
  215.  
  216.         if (TOTING(object)) DEFMSG ;
  217.  
  218.         if (DARK) OKAY(202);
  219.  
  220.         if ((object == WINE) || (object == COLA) || (object == WATER))
  221.         {    register int k;
  222.             k = obj; obj = 0;
  223.             if (AT(BOTTLE) && (LIQ(BOTTLE) == k )) obj = _BOTTLE ;
  224.             if (AT(CUP)    && (LIQ(CUP) == k)) obj = obj*100 + _CUP ;
  225.             if (obj > 4000) { return S_what; }
  226.             if (LIQLOC(loc) == k)
  227.             {    if (obj) { return S_what; } /* quibble about ambiguity */
  228.                 if (TOTING(BOTTLE) && !(BOTTLE->prop)) obj = _BOTTLE ;
  229.                 if (TOTING(CUP) && !(CUP->prop)) obj = obj*100 + _CUP ;
  230.                 if (obj > 4000)
  231.                 {    fputs("Into what?\n",stdout) ;
  232.                     mltcmd = FALSE ;
  233.                     return S_obj;
  234.                 }
  235.                 if (obj)
  236.                 {    object = OBJ(obj);
  237.                     FILLIT(object,k);
  238.                     newcon(object, object->prop + 7, k);
  239.                 } else {
  240.                     rspeak(104) ; /* nothing to put it in */
  241.                 }
  242.                 return S_okay ;
  243.             }
  244.  
  245.             if (!obj) OKAY(24);
  246.             object = OBJ(obj);
  247.         }
  248.  
  249.         if (holding >= 9) OKAY(92); /* too many */
  250.  
  251.         if (object == TOAD)
  252.         {    pspeak(TOAD,1); /* all this for fun and games! */
  253.             destry(TOAD);  /* he oughtta get points just for reading this*/
  254.             return S_okay;
  255.         }
  256.  
  257.         if (object == HANG) {
  258.             pspeak(HANG,HANG->prop + 1);
  259.             if (HANG->prop == 0) {
  260.                 HANG->prop = 2;
  261.                 juggle(HANG);
  262.             }
  263.             return S_show;
  264.         }
  265.  
  266.         if ((object == UNICRN) && UNICRN->prop)
  267.         {    pspeak(UNICRN,UNICRN->prop + 2);
  268.             if (UNICRN->prop != 1) return S_okay;
  269.             destr2(UNICRN); /* make it not fixed any more */
  270.             EINHORN->dseen = FALSE ;
  271.             EINHORN->dloc = EINHORN->oloc = DEAD;
  272.             pspeak(UNICRN, (UNICRN->prop = 0)); /* make it just a collar */
  273.             return S_okay;
  274.         }
  275.  
  276.         if (object == BOAT) object->prop += 2;
  277.  
  278.         /* if the object has a second location, you can't touch it! */
  279.         /* the reason given is it's beyond your power or just ridiculous */
  280.         if (object->conn2.where != LOST) OKAY(IFTREAS(object) ? 146 : 25);
  281.  
  282.         if ((object == RING) && (JEANNIE->dloc != DEAD))
  283.         {    if (JEANNIE->dloc != loc)
  284.                 OKAY(146); /* beyond YOUR power (need jinni) */
  285.             carry(object);
  286.             JEANNIE->oloc = JEANNIE->dloc = DEAD;
  287.             JEANNIE->dseen = FALSE;
  288.             OKAY(209); /* explain what happened to jinni */
  289.         }
  290.  
  291.         carry(object);
  292.  
  293.         if ((object == CROWN) && (HELM->prop)) return wakeking();
  294.  
  295.         if ((object == CHEST) && (SKELTN->prop))
  296.         {    rspeak(54);        /* okay, but ... */
  297.             rspeak(96);        /* it DOES have a side effect! */
  298.             SKELTN->prop = 1;
  299.             rspeak(101);    /* he always misses the first swing */
  300.             return S_miss;    /* of course, everything else is just FINE! */
  301.         }
  302.  
  303.         OKAY(54);
  304.  
  305.     case INTRANS UNLOC:
  306.         obj = 0;
  307.         if (HERE(HELM) & HELM->prop) obj = _HELM;
  308.         if (AT(DOOR)) {
  309.             if (obj) return S_what;
  310.             else obj = _DOOR;
  311.         }
  312.         if (HERE(CHAIN) && CHAIN->prop) {
  313.             if (obj) return S_what;
  314.             else obj = _CHAIN;
  315.         }
  316.         if (!obj) return S_what;
  317.         object = OBJ(obj);
  318.     case TRANS UNLOC:
  319.         if (object == HELM) return wakeking();
  320.         if (object == BEAR && HERE(CHAIN) && CHAIN->prop == 2) {
  321.             obj = _CHAIN;
  322.             object = OBJ(obj);
  323.         }
  324.         if (object == CHAIN) {
  325.             if (!HERE(KEY)) OKAY(31);
  326.             if (CHAIN->prop == 0) OKAY(37);
  327.             CHAIN->prop = 0;
  328.             destr2(CHAIN);
  329.             if (!HERE(BEAR) || BEAR->prop <= 2) OKAY(54);
  330.             BEAR->prop -= 2;
  331.             YOGI->dseen = TRUE;
  332.             YOGI->dloc = loc;
  333.             return S_show;
  334.         }
  335.         goto Leave;
  336.  
  337.     case INTRANS LOCK:
  338.         if (AT(DOOR)) obj = _DOOR;
  339.         if (HERE(CHAIN)) {
  340.             if (obj) return S_what;
  341.             else obj = _CHAIN;
  342.         }
  343.         if (!obj) return S_what;
  344.         object = OBJ(obj);
  345.     case TRANS LOCK:
  346.         if (object == CHAIN) {
  347.             if (!HERE(KEY)) OKAY(31);
  348.             if (TOTING(CHAIN)) move(CHAIN,loc);
  349.             CHAIN->prop = 1;
  350.             move2(CHAIN,FIXED);
  351.             return S_okay;
  352.         }
  353. Leave:
  354.         if (object == NULL) DEFMSG;
  355.         if (object == DOOR && HERE(KEY)) {
  356.             if (closing) {
  357.                 if (!panic) clock2 = 15;
  358.                 panic = TRUE;
  359.                 OKAY(130);
  360.             } else {
  361.                 k = 34 + DOOR->prop;
  362.                 DOOR->prop = (verb == LOCK) ? 0 : 1;
  363.                 OKAY(k + 2*(DOOR->prop));
  364.             }
  365.         } else {
  366.             if (object == DOOR) OKAY(31);
  367.             if (object == KEY) OKAY(55);
  368.             OKAY(33);
  369.         }
  370.  
  371.     case INTRANS PAY:
  372.         if (loc == O_GATE->conn1.where)
  373.             object = O_GATE;
  374.         else OKAY(8);
  375.     case TRANS PAY:
  376.         if (object != O_GATE) OKAY(8);
  377.         if (TOTING(RUG) && RUG->prop == 1) OKAY(117);
  378.         if (!HERE(WALLET)) OKAY(20);
  379.         if (WALLET->prop > 3) OKAY(21);
  380.         if (O_GATE->prop == 2) OKAY(46);
  381.         if (CRAP->prop) OKAY(113);
  382.         (WALLET->prop)++;
  383.         loc++;
  384.         return S_show;
  385.  
  386.     case TRANS BREAK:
  387.         if (object <= MINART && object >= MAXART) BREAKIT;
  388.         if (object == MIRROR) {
  389.             pspeak(object,object->prop + 3);
  390.             bonus = !(object->prop);
  391.             finish = TRUE;
  392.             return S_show;
  393.         } else if (object == DAM) {
  394.             if (DAM->prop) return S_what;
  395.             BRIDGE->prop = DAM->prop = 1;
  396.             O_GATE->prop = 2;
  397.             rspeak(41);    
  398.             if (BOAT->prop % 2) {
  399.                 move(BOAT,BOATPLC);
  400.                 k = BOAT->prop;
  401.                 BOAT->prop = 4;
  402.                 move2(BOAT,FIXED);
  403.                 rspeak(32);
  404.                 if (k == 3) {
  405.                     rspeak(45);
  406.                     die();
  407.                 }
  408.             }
  409.             return S_show;
  410.         } else DEFMSG;
  411.  
  412.     case INTRANS TEST:
  413.     case TRANS TEST:
  414.         if (object == ROPE) {
  415.             if (HERE(ROPE) && (ROPE->prop == 4 || ROPE->prop == 6)) {
  416.                 ROPE->prop = 6;
  417.                 OKAY(54);
  418.             } else OKAY(29);
  419.         }
  420.         if (!HERE(LAMP)) DEFMSG;
  421.         printf("%d turns of life left in your lamp batteries.",limit);
  422.         return S_okay;
  423.  
  424.     case INTRANS CUT:
  425.         object = ROPE;
  426.         if (!HERE(ROPE) && HERE(ROPE2)) 
  427.             object = ROPE2;
  428.         else if (!HERE(ROPE) && HERE(EROPE)) 
  429.             object = EROPE;
  430.         else if (!HERE(ROPE))
  431.             return S_what;
  432.     case TRANS CUT:
  433.         if (!HERE(AXE) && !HERE(SWORD)) DEFMSG;
  434.         if (object != ROPE && object != ROPE2 && object != EROPE) 
  435.             return S_what;
  436.         k = ROPE->prop > 3 ? 167 : 54; /* untie it sometimes */
  437.         if (object == EROPE) {
  438.             if (object->prop <3) OKAY(108); /* It's gotta be long */
  439.             ROPE->prop = 3;  /* anchored 60-foot rope */
  440.             EROPE->prop = 0; /* end of 60-foot rope */
  441.             ROPE2->prop = 2; /* loose 60-foot rope */
  442.             move(ROPE2,loc); /* bring it here */
  443.             destry(EROPE2);
  444.         } else {
  445.             if (object->prop % 2)  OKAY(168); /* not at anchor */
  446.             if (object->prop == 2) OKAY(108); /* too short */
  447.             ROPE->prop = ROPE2->prop = 2;
  448.             move(ROPE2,loc);
  449.         }
  450.         rspeak(k);
  451.         return S_show;
  452.  
  453.     case INTRANS TIE:
  454.         if (HERE(ROPE)) object = ROPE;
  455.         if (HERE(ROPE2)) object = ROPE2;
  456.         if (HERE(BOAT)) {
  457.             if (object != NULL) return S_what;
  458.             object = BOAT;
  459.         }
  460.     case TRANS TIE:
  461.         if (object == BOAT) {
  462.             if (object->prop == 4) OKAY(30);
  463.             if (!(object->prop % 2)) OKAY(27);
  464.             object->prop--;
  465.             OKAY(54);
  466.         }
  467.         if (HERE(ROPE) && HERE(ROPE2) && ROPE->prop == 2) {
  468.             ROPE->prop = 4;
  469.             destry(ROPE2);
  470.             destry(EROPE2);    /* just in case it was rigged */
  471.             OKAY(54);
  472.         }
  473.         /* NOTE: fall through to RIG when tying complete rope */
  474.     case INTRANS RIG:
  475.     case TRANS RIG:
  476.         object = NULL;
  477.         if (HERE(ROPE) && !(ROPE->prop % 2)) object = ROPE;
  478.         else if (HERE(ROPE2) && ROPE2->prop == 2) object = ROPE2;
  479.         else OKAY(205);   /* You have no rope */
  480.         {    register struct rtr *rtr;
  481.             register struct cvobj *obj2;
  482.  
  483.             obj2 = object + 2; /* EROPE object */
  484.             k = loc - cvloc;
  485.             for (rtr = rtrav; rtr->top != -1; rtr++)
  486.                 if (k == rtr->top) break;
  487.             if (rtr->top == -1) 
  488.                 OKAY(204);   /* nothing to tie it to */
  489.             if (rtr->mid == 0 && object->prop == 2) 
  490.                 rspeak(206); /* It won't reach */
  491.             object->prop ++;     /* tie it */
  492.             if (TOTING(object)) move(object,loc); /* drop it */
  493.             move2(object,FIXED); /* fix it */
  494.             move(obj2, &(cvloc[rtr->mid])); /* move the end */
  495.             move2(obj2,FIXED);   /* fix the end */
  496.             obj2->prop = 0;      /* assume the bottom */
  497.             if (object==ROPE && !(rtr->bot) && ROPE->prop!=3) {
  498.                 if (rtr->mid == DUNGEON) {
  499.                 obj2->prop = 3; /* show the rest of the rope */
  500.                 }
  501.                 else {
  502.                 obj2->prop = 4; /* show the rest of the rope */
  503.                 }
  504.             }
  505.             if (rtr->bot && object == ROPE && object->prop != 3) {
  506.                 if (rtr->mid) {
  507.                     obj2 = EROPE2;
  508.                     EROPE->prop = (int)(ROPE->prop/4) +1;
  509.                 } else obj2 = EROPE;
  510.                 move(obj2,&(cvloc[rtr->bot]));
  511.                 move2(obj2,FIXED);
  512.             }
  513.             return S_show;
  514.         }
  515.  
  516.     case INTRANS UNTIE:
  517.         if (HERE(BOAT)) {
  518.             if (HERE(ROPE) || HERE(ROPE2)) return S_what;
  519.             object = BOAT;
  520.         } else if (HERE(ROPE)) object = ROPE;
  521.         else if (HERE(ROPE2)) object = ROPE2;
  522.     case TRANS UNTIE:
  523.         if (object == BOAT) {
  524.             if (object->prop == 4) OKAY(30);
  525.             if (object->prop % 2) OKAY(26);
  526.             object->prop ++ ;
  527.             OKAY(54);
  528.         }
  529.         if (HERE(ROPE) && (ROPE->prop == 4 || ROPE->prop == 6)) {
  530.             ROPE->prop = ROPE2->prop = 2;
  531.             move(ROPE2,loc);
  532.             rspeak(54);
  533.             return S_show;
  534.         }
  535.         if (HERE(EROPE) && (ROPE->prop > 3) && (EROPE->prop > 2)) {
  536.             /* dividing a long rope while it's rigged */
  537.             ROPE->prop = 3;  /* make it short */
  538.             EROPE->prop = 0; /* make the end short, too */
  539.             ROPE2->prop = 2; /* create a short coil */
  540.             destry(EROPE2);  /* with no end */
  541.             move(ROPE2,loc); /* bring it here */
  542.             rspeak(54);
  543.             return S_show;
  544.         }
  545.         /* now try this as an "unrig" */
  546.         if (HERE(ROPE) && (ROPE->prop % 2)) object = ROPE;
  547.         else if (HERE(ROPE2) && ROPE2->prop == 3) object = ROPE2;
  548.         else DEFMSG;
  549.         object->prop--;
  550.         destr2(object);
  551.         if (object == ROPE && EROPE->prop) destry(EROPE2);
  552.         destry(object+2); /* destroy the end */
  553.         return S_show;
  554.  
  555.     /* rubbing the helm gets you in trouble (but you gotta do it),
  556.         rubbing the lamp gives you a ribbing, rubbing anything else is
  557.         just useless */
  558.     case TRANS RUB:
  559.         if (object == LAMP) DEFMSG;
  560.         if (object == HELM && HELM->prop) return wakeking();
  561.         OKAY(76);
  562.  
  563.     case TRANS INVENT:
  564.     case TRANS FIND:
  565.         if (object == UNICRN && UNICRN->prop && HERE(UNICRN))
  566.             return unicorn();
  567.         if (TOTING(object)) OKAY(24);
  568.         if (closed) OKAY(138);
  569.         if (obj == _DWARF) {
  570.             register struct monster *cre;
  571.             for (cre = MINDWR; cre <= MAXDWR; ++cre) {
  572.                 if (cre->dloc == loc && dflag >= 2) {
  573.                     OKAY(94);
  574.                 }
  575.             }
  576.         }
  577.         if (AT(object)
  578.                 || (LIQ(BOTTLE) == obj && AT(BOTTLE))
  579.                 || (LIQLOC(loc) == obj)) {
  580.             OKAY(94);
  581.         }
  582.  
  583.     case INTRANS INVENT:
  584.         k = FALSE;
  585.         for (object = cvobj; object->desc != NULL; object++) {
  586.             if (strlen(object->desc) && TOTING(object)) {
  587.                 if (!k) {rspeak(99); k = TRUE; }
  588.                 blklin = FALSE;
  589.                 fputs("  ",stdout);
  590.                 putcode(object->desc);
  591.                 putchar('\n');
  592.                 if ((object == CUP || object == BOTTLE)
  593.                     && object->prop) {
  594.                     pspeak(object, object->prop + 3);
  595.                 }
  596.                 blklin = TRUE;
  597.             }
  598.         }
  599.         if (!k) rspeak(98);
  600.         return S_okay;
  601.  
  602.     case TRANS CALM:
  603.         if (object == UNICRN && UNICRN->prop) return unicorn();
  604.         DEFMSG;
  605.  
  606.     case INTRANS KILL:
  607.         obj = 0;
  608.         if (ME->dloc == loc) obj = _SELF;
  609.         if (YOGI->dloc == loc) {
  610.             if (obj) return S_what;
  611.             else obj = _BEAR;
  612.         }
  613.         if (!obj) {
  614.             register struct monster *cre;
  615.             for (cre = orcs; cre->iloc != -1; ++cre) {
  616.                 if (cre->dloc == loc) OKAY(49);
  617.             }
  618.             OKAY(44);
  619.         }
  620.         object = OBJ(obj);
  621.     case TRANS KILL:
  622.         if (object >= MINART && object <= MAXART) BREAKIT;
  623.         if (object == SELF) return suicide();
  624.         if (object == BEAR) OKAY(165);
  625.         OKAY(49);
  626.  
  627.     case INTRANS EAT:
  628.         if (HERE(FOOD)) {
  629.             destry(FOOD);
  630.             OKAY(72);
  631.         } else {
  632.             return S_what;
  633.         }
  634.  
  635.     case TRANS EAT:
  636.         if (object == FOOD) {
  637.             destry(FOOD);
  638.             OKAY(72);
  639.         }
  640.  
  641.         if (object == BEAR
  642.                 || object == SPIDER
  643.                 || object == SELF
  644.                 || object == DRAGON
  645.                 || object == SKELTN
  646.                 || object == BALROG
  647.                 || object == DWARF) OKAY(71);
  648.         DEFMSG;
  649.  
  650.     case INTRANS DRINK:
  651.         obj = LIQLOC(loc);
  652.         if (HERE(CUP)) {
  653.             if (obj) return S_what;
  654.             else obj = LIQ(CUP);
  655.         }
  656.         if (HERE(BOTTLE)) {
  657.             if (obj) return S_what;
  658.             else obj = LIQ(BOTTLE);
  659.         }
  660.         if (!obj) return S_what;
  661.         object = OBJ(obj);
  662.     case TRANS DRINK:
  663.         if (object != BOTTLE && object != CUP) {
  664.             k = obj;
  665.             obj = 0;
  666.             if (HERE(CUP) && OBJ(LIQ(CUP)) == object) obj = _CUP;
  667.             if (HERE(BOTTLE) && OBJ(LIQ(BOTTLE)) == object) {
  668.                 if (obj) OKAY(143); /* From what? (2 possibilities) */
  669.                 obj = _BOTTLE;
  670.             }
  671.             if (OBJ(LIQLOC(loc)) == object) {
  672.                 if (obj) OKAY(143); /* From what? (2 possibilities) */
  673.                 OKAY(object == WATER ? 73 : 72);
  674.             }
  675.             if (!obj) OKAY(143); /* from what? no possibilities */
  676.         }
  677.         object = OBJ(obj); /* object is now the container */
  678.         if ((k=LIQ(object)) == 0) {pspeak(object,11); return S_okay; }
  679.         rspeak(object == WATER ? 73 : 72); /* take the drink */
  680.         object->prop = 0;
  681.         newcon(object, 7, k);
  682.         return S_okay;
  683.  
  684.     case INTRANS SIT:
  685.         if (!HERE(THRONE) || THRONE->prop == 0) {
  686.             if ((HERE(BOAT) && BOAT->prop/2 == 1)
  687.                     || (TOTING(RUG) && RUG->prop == 1))
  688.                 rspeak(192);
  689.             else DEFMSG;
  690.             return S_okay;
  691.         }
  692.         k = 0;
  693.         if (HERE(SCEPT)) k++;
  694.         if (HERE(CROWN)) k++;
  695.         if (HERE(CAPE)) k++;
  696.         if (HERE(ORB)) k++;
  697.         pspeak(THRONE,2);
  698.         pspeak(THRONE,k+3);
  699.         oldlc2 = loc;
  700.         if (k == 0) die();
  701.         if (k != 4) return S_show;
  702.         /* He got it right -- cast him into new universe of adventures */
  703.         THRONE->prop = 0;
  704.         destr2(THRONE); /* throne is now a treasure */
  705.         newloc = &(cvloc[124]);
  706.         /* start some new monsters */
  707.         JEANNIE->dloc = RING->conn1.where;
  708.         SLASHER->dloc = JEWLRY->conn1.where;
  709.         EINHORN->dloc = RUG->conn1.where;
  710.         return S_move;
  711.  
  712.     case INTRANS FLY:
  713.         if (!TOTING(RUG)) DEFMSG;
  714.         if (RUG->prop) OKAY(154);
  715.         if (loc > &(cvloc[137])) OKAY(136);
  716.         if (loc < &(cvloc[63])) OKAY(136);
  717.         RUG->prop = 1;
  718.         OKAY(54);
  719.  
  720.     case TRANS WAVE:
  721.         if (!TOTING(object)) OKAY(29);
  722.         if (closing) DEFMSG;
  723.         if (object != SCEPT) OKAY(42);
  724.         if (HERE(HELM) && HELM->prop) return wakeking();
  725.         if (ARTHUR->dloc != loc) OKAY(76);
  726.         ARTHUR->dloc = DEAD;
  727.         ARTHUR->dseen = FALSE;
  728.         move(HELM,loc);    /* bring helm here (was destroyed while Arthur
  729.                             was walking around */
  730.         destr2(HELM);    /* make it takeable */
  731.         pspeak(HELM,6);    /* crumble Arthur to dust */
  732.         newloc = loc;
  733.         return S_move;
  734.  
  735.     case INTRANS BRIEF:
  736.         abbnum = 10000;
  737.         detail = 99;
  738.         OKAY(156);
  739.  
  740.     case INTRANS READ:
  741.         if (DARK) return S_what;
  742.         if (HERE(SCROLL)) object = SCROLL;
  743.         else return S_what;
  744.     case TRANS READ:
  745.         if (DARK) return S_dark;
  746.         if (object != SCROLL) DEFMSG;
  747.         OKAY(126);
  748.  
  749.     case INTRANS SCORE:
  750.         getscore();
  751.         printf("\nIf you were to quit now (after %d moves), you would \
  752. score %d\nout of a possible %d points.\n",turns,score,mxscore);
  753.         return S_okay;
  754.  
  755.     case TRANS BLAST:
  756.     case INTRANS BLAST:
  757.         if (!closed) DEFMSG;
  758.         finish = TRUE;
  759.         return S_show;
  760.  
  761.     case INTRANS ON:
  762.         if (!HERE(LAMP)) DEFMSG;
  763.         object = LAMP;
  764.     case TRANS ON:
  765.         dolight(object,1);
  766.         return S_light;
  767.  
  768.     case INTRANS OFF:
  769.         if (!HERE(LAMP)) DEFMSG;
  770.         object = LAMP;
  771.     case TRANS OFF:
  772.         dolight(object,0);
  773.         return S_light;
  774.  
  775.     case INTRANS DESCRB:
  776.     case INTRANS TOUCH:
  777.         if (detail++<3) rspeak(15);
  778.         wzdark = FALSE;
  779.         loc->abb = 0;
  780.         newloc = loc;
  781.         return S_move;
  782.  
  783.     case TRANS TOUCH:
  784.         if (object == TOAD) {
  785.             pspeak(TOAD,1);
  786.             destry(TOAD);
  787.             return S_okay;
  788.         }
  789.         if (object >= MINART && object <= MAXART) BREAKIT;
  790.         if (object == UNICRN && HERE(object) && object->prop)
  791.             return unicorn();
  792.         /* fall through to describe */
  793.     case TRANS DESCRB:
  794.         k = vocab(oword,3);
  795.         if (k > 0) OKAY(k%1000);
  796.         rspeak(15);
  797.         wzdark = FALSE;
  798.         loc->abb = 0;
  799.         newloc = loc;
  800.         return S_move;
  801.  
  802.     case INTRANS PLAY:
  803.         if (!HERE(HARP)) return S_what;
  804.         object = HARP;
  805.     case TRANS PLAY:
  806.         if (object != HARP) DEFMSG;
  807.         pspeak(object,1);
  808.         if (UNICRN->prop == 2 && HERE(UNICRN)) {
  809.             UNICRN->prop = 1;
  810.             OKAY(222);
  811.         }
  812.         if (UNICRN->prop != -1 && UNICRN->prop != 2)
  813.             return S_okay;
  814.         if ((loc >= &(cvloc[62]))
  815.                 && (dflag >= 2)
  816.                 && (EINHORN->dloc != DEAD)
  817.                 && (!(EINHORN->dseen))
  818.                 && (!(BADPLC(loc)))) {
  819.             move(UNICRN,loc);
  820.             EINHORN->dloc = EINHORN->oloc = loc;
  821.             EINHORN->dseen = TRUE;
  822.             rspeak(222);
  823.         }
  824.         return S_okay;
  825.  
  826.     case INTRANS DROP:
  827.     case INTRANS SAY:
  828.     case INTRANS RUB:
  829.     case INTRANS FIND:
  830.     case INTRANS BREAK:
  831.     case INTRANS THROW:
  832.     case INTRANS WAVE:
  833.     case INTRANS CALM:
  834.     case INTRANS WAKE:
  835.     case TRANS SIT:
  836.         return S_what;
  837.  
  838.     case INTRANS HELP:
  839.         rspeak(157); 
  840.         while (getchar() != '\n') ;
  841.         rspeak(158);
  842.         return S_okay;
  843.  
  844.     case INTRANS QUIT:
  845.         if (!(gaveup = yes(22,54,54))) return S_okay;
  846.         finish = TRUE;
  847.         return S_show;
  848.  
  849.     case TRANS QUIT:
  850.     case TRANS SCORE:
  851.     case TRANS SAVE:
  852.     case TRANS RESTOR:
  853.     case TRANS BRIEF:
  854.     case TRANS WALK:
  855.     case TRANS FLY:
  856.     case TRANS WAKE:
  857.     case TRANS HELP:
  858.         DEFMSG;
  859.  
  860.     case INTRANS NOTHI:
  861.     case TRANS NOTHI:
  862.         OKAY(54);
  863.  
  864.     default:
  865.         fputs("Unknown verb.\n",stdout);
  866.         return S_okay;
  867.     } /* end of verb switch */
  868. }
  869.